package com.aps.algorithm.heuristic.genetic.model;

import lombok.Getter;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;


/**
 * 染色体类（遗传算法中的解表示）
 * 
 * 在APS排程系统的遗传算法中，染色体代表一个完整的排产方案。
 * 基因序列由工序组成，表示工序的执行顺序。
 * 
 * 遗传算法核心概念：
 * - 染色体：完整的解决方案（排产方案）
 * - 基因：解决方案的组成部分（工序）
 * - 适应度：解决方案质量的数值化评估
 * 
 * 业务场景：
 * - 染色体1：[J1-1, J2-1, J1-2, J3-1, J2-2, J1-3, J3-2, J3-3] 
 * - 染色体2：[J2-1, J1-1, J3-1, J1-2, J3-2, J2-2, J1-3, J3-3]
 * - 每个染色体代表不同的工序执行顺序，会产生不同的排产效果
 * 
 * @author APS System
 * @version 1.0
 */
@Getter
public class Chromosome<T extends Gene> implements Serializable {
    //种群编码 （基于基因维度进行编码） 作用判断是否生成了重复的染色体
    private String chromosomeCode;

    /** 基因序列，即工序执行顺序 */
    private List<T> geneSequence;
    
    /** 适应度值，用于评估该排产方案的优劣程度 */
    private double fitness;
    
    /** 是否存在机器时间冲突 */
//    private boolean hasMachineConflicts;


    public String getChromosomeCode() {
        return chromosomeCode;
    }

    public void setChromosomeCode(String chromosomeCode) {
        this.chromosomeCode = chromosomeCode;
    }

    /**
     * 构造函数
     * 
     * @param geneSequence 基因序列（工序执行顺序）
     */
    public Chromosome(List<T> geneSequence) {
        this.geneSequence = geneSequence != null ? new ArrayList<>(geneSequence) : new ArrayList<>();
        this.fitness = 0.0;
//        this.hasMachineConflicts = false;
    }

    /**
     * 染色体基因排列好后 染色体编码
     * @return
     */
    public void preparedChromosomeCode() {
        if(geneSequence != null && !geneSequence.isEmpty()) {
            //订单 id +  工序id  =  基因
            this.chromosomeCode = geneSequence.stream()
                    .map(T::getGeneCode).collect(Collectors.joining("&&"));
        }
    }


    
    /**
     * 默认构造函数，创建空的染色体
     */
    public Chromosome() {
        this(new ArrayList<>());
    }
    
    /**
     * 复制染色体
     * 
     * 在遗传算法的交叉和变异操作中，需要创建染色体的副本
     * 以避免修改原始染色体。
     * 
     * @return 当前染色体的深度拷贝
     */
    public Chromosome<T> copy() {
        Chromosome<T> copy = new Chromosome<>(new ArrayList<>(this.geneSequence));
        copy.fitness = this.fitness;
        copy.chromosomeCode = this.chromosomeCode;
//        copy.hasMachineConflicts = this.hasMachineConflicts;
        return copy;
    }
    /**
     * 获取基因序列的长度
     * 
     * @return 基因序列长度
     */
    public int getGeneLength() {
        return geneSequence.size();
    }
    
    /**
     * 检查染色体是否为空
     * 
     * @return 如果基因序列为空返回true，否则返回false
     */
    public boolean isEmpty() {
        return geneSequence.isEmpty();
    }

    
    // Getter和Setter方法
    
    /**
     * 获取基因序列
     * 
     * @return 基因序列
     */
    public List<T> getGeneSequence() {
        return geneSequence;
    }
    
    /**
     * 设置基因序列
     * 
     * @param geneSequence 基因序列
     */
    public void setGeneSequence(List<T> geneSequence) {
        this.geneSequence = geneSequence != null ? geneSequence : new ArrayList<>();
    }
    
    /**
     * 获取适应度值
     * 
     * @return 适应度值
     */
    public double getFitness() {
        return fitness;
    }
    
    /**
     * 设置适应度值
     * 
     * @param fitness 适应度值
     */
    public void setFitness(double fitness) {
        this.fitness = fitness;
    }
    
    /**
     * equals方法，基于基因序列进行比较
     * 
     * @param obj 要比较的对象
     * @return 如果基因序列相同返回true，否则返回false
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        
        Chromosome<?> that = (Chromosome<?>) obj;
        return geneSequence.equals(that.geneSequence);
    }
    
    /**
     * hashCode方法，基于基因序列
     * 
     * @return 散列值
     */
    @Override
    public int hashCode() {
        return geneSequence.hashCode();
    }
}
